package cqwu.testSSH.Manager.Utils.dao;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class BaseDao3 {
	
	private SessionFactory sessionFactory = null;
	
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}
	
	/*
	 * getCurrentSession() 会动关闭session 使用的是当前的session 事务。
	 */
	public Session getSession() {
		return sessionFactory.getCurrentSession();
	}
	
	/*
	 * openSession 需要手动关闭session 意思是大可iyige新的session
	 */
	public Session getNewSession(){
		return sessionFactory.openSession();
	}
	
	public void flush(){
		getSession().flush();
	}
	
	
	public void clear(){
		getSession().clear();
	}
	

	/**
	 * 根据id查询所在的对象
	 * @param clazz  类
	 * @param id 查找的id
	 * @return 该类
	 */
	public Object findById(Class clazz,Serializable id){
		return getSession().get(clazz, id);
	}
	
	/**
	 * 查询所有的该对象信息
	 * @param entityClass 类
	 * @return 该类的集合
	 */
	public List findAll(Class entityClass){
		Criteria criteria = getSession().createCriteria(entityClass);
		return criteria.list();
	}
	
	/**
	 * 保存操作
	 * @param entity 实体类
	 * @return 成功返回true否则返回false
	 */
	public  boolean save(Object entity){
		try{
			Session session =  getNewSession();
			session.save(entity);
			session.flush();
			session.clear();
			session.close();
			return true;
		}catch (Exception e) {
			return false;
		}
	}
	
	/**
	 * 删除操作
	 * @param entity  实体对象
	 * @return 成功返回true 失败返回false
	 */
	public boolean delete(Object entity){
		try {
			Session session = getNewSession();
			session.delete(entity);
			session.flush();
			session.clear();
			session.close();
			return true;
		} catch (Exception e) {
			return false;
		}
	}
	
	/**
	 * 删除操作 根据操作对象和id进行删除
	 * @param c  删除的对象
	 * @param id  该对象的id值
	 * @return 操作成功返回true 失败返回false
	 */
	public boolean delete(Class c,Integer id){
		try {
			Session session = getNewSession();
			Object obj = session.get(c, id);
			session.delete(obj);
			flush();
			clear();
			return true;
		} catch (Exception e) {
			return false;
		}
	}

	/**
	 * 批量删除操作
	 * @param c  需要删除的类
	 * @param ids id集合
	 * @return 删除成功返回true 失败返回false
	 */
	public boolean deleteALl(Class c,Integer[] ids){
		try {
			for(Integer id : ids){
				Object obj = getSession().get(c, id);
				if(obj != null){
					getSession().delete(obj);
				}
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	/**
	 * 更新
	 * @param entity 实体对象
	 * @return 成功返回true 失败返回false
	 */
	public boolean update(Object entity){
		try {
			Session session = getSession();
			System.out.println("session = "+session);
			session.update(entity);
			session.flush();
			session.clear();
			session.close();
			return true;
		} catch (Exception e) {
			return false;
		}
	}
	
	/**
	 * 分页查询
	 * @param entity 查询的实体对象
	 * @param first 分页的起始页码
	 * @param size  页面大小
	 * @return 该实体对象的集合
	 */
	public List<Object> query(Object entity,int first, int size){
		try {
			Criteria criteria = getSession().createCriteria(entity.getClass());
			criteria.setFirstResult(first);
			criteria.setFetchSize(size);
			return  criteria.list();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	
}
